Exercise for Recurrent Neural Networks: PdM Regression
By Prof. Seungchul Lee
http://iai.postech.ac.kr/
Industrial AI Lab at POSTECH
http://iai.postech.ac.kr/
Industrial AI Lab at POSTECH
1. Problem Definition¶
- Predictive Maintenance
- This predictive maintenance project focuses on the techniques used to predict when an in-service machine will fail, so that maintenance can be planned in advance.
- Overview of the RUL estimation strategy
- The remaining life of a test unit is estimated based on the actual life of a training unit that has the most similar degradation pattern.
- Data description
- Training data: It is the aircraft engine run-to-failure data.
- Testing data: It is the aircraft engine operating data without failure events recorded.
- Ground truth data: It contains the information of true remaining cycles for each engine in the testing data.
- Operational conditions
- Altitude (0 ~ 42,000 feet), Mach number (0 ~ 0.84) and throttle resolver angle (20 ~ 100)
- 21 sensors
- Different measurements related to the engine state at runtime.
2. Import Library¶
In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from sklearn import preprocessing
3. Load Data¶
In [2]:
train_df = pd.read_csv('./data_files/PM_train.txt', sep=" ", header=None)
train_df.head()
Out[2]:
In [3]:
test_df = pd.read_csv('./data_files/PM_test.txt', sep=" ", header=None)
test_df.head()
Out[3]:
In [4]:
truth_df = pd.read_csv('./data_files/PM_truth.txt', sep=" ", header=None)
truth_df.head()
Out[4]:
3.1. Plot¶
In [5]:
def plot_sensor_data(data, purpose):
for j in data.keys().difference([0,1,26,27]).values:
max_cycle = data.groupby([0]).count()[j].max()
if purpose == 'train':
plt.figure(figsize = (20, 1.5))
for i in range(data[0].max()):
padding = max_cycle - data[data[0] == i][j].values.shape[0]
plt.plot(np.arange(padding, max_cycle), data[data[0] == i][j].values)
if j == 2 or j == 3 or j == 4:
plt.title(str(j-1) + 'th setting')
else:
plt.title(str(j-4) + 'th sensor')
plt.vlines(max_cycle, data[j].min(), data[j].max(), colors = 'r', linestyles = 'dashed')
plt.text(max_cycle+1, data[j].median(), "failure", fontsize=14)
plt.show()
if purpose == 'test':
plt.figure(figsize = (20, 1.5))
for i in range(data[0].max()):
plt.plot(data[data[0] == i][j].values)
if j == 2 or j == 3 or j == 4:
plt.title(str(j-1) + 'th setting')
else:
plt.title(str(j-4) + 'th sensor')
plt.text(max_cycle+1, data[j].median(), "on working", fontsize=14)
plt.show()
In [6]:
# plot train data
plot_sensor_data(train_df, 'train')
In [7]:
# plot test data
plot_sensor_data(test_df, 'test')
4. Pre-processing¶
4.1. Drop NaN column¶
In [8]:
train_df.drop(train_df.columns[[26, 27]], axis=1, inplace=True)
train_df.columns = ['id', 'cycle', 'setting1', 'setting2', 'setting3', 's1', 's2', 's3',
's4', 's5', 's6', 's7', 's8', 's9', 's10', 's11', 's12', 's13', 's14',
's15', 's16', 's17', 's18', 's19', 's20', 's21']
test_df.drop(test_df.columns[[26, 27]], axis=1, inplace=True)
test_df.columns = ['id', 'cycle', 'setting1', 'setting2', 'setting3', 's1', 's2', 's3',
's4', 's5', 's6', 's7', 's8', 's9', 's10', 's11', 's12', 's13', 's14',
's15', 's16', 's17', 's18', 's19', 's20', 's21']
truth_df.drop(truth_df.columns[[1]], axis=1, inplace=True)
4.2. Train Data¶
In [9]:
train_df.head()
Out[9]:
4.2.1. Labeling¶
In [10]:
train_df['RUL'] = train_df.groupby(['id'])['cycle'].transform(max) - train_df['cycle']
train_df.head()
Out[10]:
4.2.2. Normalize¶
In [11]:
cols_normalize = train_df.columns.difference(['id','cycle','RUL'])
cols_normalize
Out[11]:
In [12]:
# normalize
min_max_scaler = preprocessing.MinMaxScaler()
norm_train_df = pd.DataFrame(min_max_scaler.fit_transform(train_df[cols_normalize]),
columns=cols_normalize,
index=train_df.index)
norm_train_df.head()
Out[12]:
In [13]:
join_df = train_df[train_df.columns.difference(cols_normalize)].join(norm_train_df)
train_df = join_df.reindex(columns = train_df.columns)
train_df.head()
Out[13]:
4.3. Test data¶
4.3.1. Labeling¶
In [14]:
# Get value of max cycle
rul = pd.DataFrame(test_df.groupby('id')['cycle'].max()).reset_index()
rul.columns = ['id', 'max']
rul.head()
Out[14]:
In [15]:
truth_df.columns = ['more']
truth_df['id'] = truth_df.index + 1
truth_df.head()
Out[15]:
In [16]:
truth_df['max'] = truth_df['more'] + rul['max']
truth_df.drop('more', axis=1, inplace=True)
truth_df.head()
Out[16]:
In [17]:
# Get RUL
test_df = test_df.merge(truth_df)
test_df['RUL'] = test_df['max'] - test_df['cycle']
test_df.drop('max', axis=1, inplace=True)
test_df.head()
Out[17]:
4.3.2. Normalize¶
In [18]:
norm_test_df = pd.DataFrame(min_max_scaler.transform(test_df[cols_normalize]),
columns=cols_normalize,
index=test_df.index)
test_join_df = test_df[test_df.columns.difference(cols_normalize)].join(norm_test_df)
test_df = test_join_df.reindex(columns = test_df.columns)
test_df = test_df.reset_index(drop=True)
test_df.head()
Out[18]:
4.4. Data Generation¶
In [19]:
# function to generate input sequences
def gen_sequence(id_df, seq_length, seq_cols):
data_matrix = id_df[seq_cols].values
num_elements = data_matrix.shape[0]
for start, stop in zip(range(0, num_elements-seq_length), range(seq_length, num_elements)):
yield data_matrix[start:stop, :]
# function to generate labels
def gen_labels(id_df, seq_length, label):
data_matrix = id_df[label].values
num_elements = data_matrix.shape[0]
return data_matrix[seq_length:num_elements, :]
In [20]:
# generate data
n_step = 50
sensor_cols = ['s' + str(i) for i in range(1,22)]
x_cols = ['setting1', 'setting2', 'setting3']
x_cols.extend(sensor_cols)
X_train = np.concatenate(list(list(gen_sequence(train_df[train_df['id']==id], n_step, x_cols)) for id in train_df['id'].unique()))
y_train = np.concatenate(list(list(gen_labels(train_df[train_df['id']==id], n_step, ['RUL']) for id in train_df['id'].unique())))
print(X_train.shape)
print(y_train.shape)
5. Build a Model¶
In [21]:
n_step = 50
n_input = train_df.shape[1] - 3
## LSTM shape
n_lstm1 = 100
n_lstm2 = 50
## Fully connected
n_hidden = 100
n_output = 1
n_batch = 64
In [22]:
weights = {
'hidden' : tf.Variable(tf.random_normal([n_lstm2, n_hidden], stddev = 0.01)),
'output' : tf.Variable(tf.random_normal([n_hidden, n_output], stddev = 0.01))
}
biases = {
'hidden' : tf.Variable(tf.random_normal([n_hidden], stddev = 0.01)),
'output' : tf.Variable(tf.random_normal([n_output], stddev = 0.01))
}
x = tf.placeholder(tf.float32, [None, n_step, n_input])
y = tf.placeholder(tf.float32, [None, n_output])
In [23]:
def LSTM_model(x, weights, biases):
with tf.variable_scope('rnn'):
with tf.variable_scope('lstm1'):
lstm1 = tf.nn.rnn_cell.LSTMCell(n_lstm1)
h1, c1 = tf.nn.dynamic_rnn(lstm1, x, dtype = tf.float32)
with tf.variable_scope('lstm2'):
lstm2 = tf.nn.rnn_cell.LSTMCell(n_lstm2)
h2, c2 = tf.nn.dynamic_rnn(lstm2, h1, dtype = tf.float32)
# Build classifier
hidden = tf.add(tf.matmul(h2[:,-1,:], weights['hidden']), biases['hidden'])
hidden = tf.nn.relu(hidden)
output = tf.add(tf.matmul(hidden, weights['output']), biases['output'])
return output
In [24]:
LR = 0.001
pred = LSTM_model(x, weights, biases)
loss = tf.square(tf.subtract(y, pred))
loss = tf.reduce_mean(loss)
optm = tf.train.AdamOptimizer(LR).minimize(loss)
6. Batch Maker¶
In [25]:
dataset_train = tf.data.Dataset.from_tensor_slices((X_train, y_train))
dataset_train = dataset_train.shuffle(100000).repeat().batch(n_batch)
iterator_train = dataset_train.make_one_shot_iterator()
next_batch_train = iterator_train.get_next()
7. Optimize¶
In [26]:
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
n_iter = 5000
n_prt = 250
for i in range(n_iter):
train_x, train_y = sess.run(next_batch_train)
sess.run(optm, feed_dict = {x: train_x, y: train_y.reshape(-1,1)})
c = sess.run(loss, feed_dict = {x: train_x, y: train_y.reshape(-1,1)})
if i % n_prt == 0:
print("Iter : {}".format(i), "Cost : {}".format(c))
8. Test or Evaluation¶
In [27]:
test_x = [test_df[test_df['id']==id][x_cols].values[-n_step:]
for id in test_df['id'].unique() if len(test_df[test_df['id']==id]) >= n_step]
test_x = np.asarray(test_x).astype(np.float32)
print(test_x.shape)
In [28]:
y_mask = [len(test_df[test_df['id']==id]) >= n_step for id in test_df['id'].unique()]
test_y = test_df.groupby('id')['RUL'].nth(-1)[y_mask].values
test_y = test_y.reshape(test_y.shape[0],1).astype(np.float32)
print(test_y.shape)
In [29]:
test_pred = sess.run(pred, feed_dict = {x: test_x})
plt.figure(figsize=(15,8))
plt.plot(test_y.ravel(), label = 'Real')
plt.plot(test_pred.ravel(), label = 'Prediction')
plt.legend(fontsize = 15)
plt.show()
